home *** CD-ROM | disk | FTP | other *** search
/ Mac Easy 2010 May / Mac Life Ubuntu.iso / casper / filesystem.squashfs / usr / share / hplip / pcard / photocard.pyc (.txt) < prev   
Encoding:
Python Compiled Bytecode  |  2009-04-20  |  19.0 KB  |  712 lines
  1. # Source Generated with Decompyle++
  2. # File: in.pyc (Python 2.6)
  3.  
  4. import struct
  5. import time
  6. import fnmatch
  7. import mimetypes
  8. import array
  9. from base.g import *
  10. from base.codes import *
  11. from base import device, utils, exif
  12.  
  13. try:
  14.     import pcardext
  15. except ImportError:
  16.     if not os.getenv('HPLIP_BUILD'):
  17.         log.error('PCARDEXT could not be loaded. Please check HPLIP installation.')
  18.         sys.exit(1)
  19.     
  20. except:
  21.     os.getenv('HPLIP_BUILD')
  22.  
  23. ACK = 256
  24. NAK = 257
  25. READ_CMD = 16
  26. WRITE_CMD = 32
  27. SECTOR_SIZE = 512
  28. MAX_CACHE = 512
  29. INITIAL_PCARDFILE_BUFFER = 20 * SECTOR_SIZE
  30. INCREMENTAL_PCARDFILE_BUFFER = 2 * SECTOR_SIZE
  31.  
  32. class PhotoCardFile:
  33.     
  34.     def __init__(self, pc, name = None):
  35.         self.pos = 0
  36.         self.closed = True
  37.         self.file_size = 0
  38.         self.pc = pc
  39.         self.buffer = array.array('c')
  40.         if name is not None:
  41.             self.open(name)
  42.         
  43.         self.buffer_size = INITIAL_PCARDFILE_BUFFER
  44.         self.buffer.fromstring(pcardext.read(self.name, 0, self.buffer_size))
  45.  
  46.     
  47.     def open(self, name):
  48.         self.closed = False
  49.         self.name = name
  50.  
  51.     
  52.     def seek(self, offset, whence = 0):
  53.         if whence == 0:
  54.             self.pos = offset
  55.         elif whence == 1:
  56.             self.pos += offset
  57.         elif whence == 2:
  58.             self.pos = self.file_size - offset
  59.         else:
  60.             return None
  61.         return self
  62.  
  63.     
  64.     def tell(self):
  65.         return self.pos
  66.  
  67.     
  68.     def read(self, size):
  69.         if size > 0:
  70.             if self.pos + size < self.buffer_size:
  71.                 data = self.buffer[self.pos:self.pos + size].tostring()
  72.                 self.pos += size
  73.                 return data
  74.             while self.pos + size >= self.buffer_size:
  75.                 self.buffer.fromstring(pcardext.read(self.name, self.buffer_size, INCREMENTAL_PCARDFILE_BUFFER))
  76.                 self.buffer_size += INCREMENTAL_PCARDFILE_BUFFER
  77.                 continue
  78.                 self
  79.             return self.read(size)
  80.         size > 0
  81.  
  82.     
  83.     def close(self):
  84.         self.closed = True
  85.         self.pos = 0
  86.  
  87.  
  88.  
  89. class PhotoCard:
  90.     
  91.     def __init__(self, dev_obj = None, device_uri = None, printer_name = None):
  92.         if dev_obj is None:
  93.             self.device = device.Device(device_uri, printer_name)
  94.             self.device.open()
  95.             self.close_device = True
  96.         else:
  97.             self.device = dev_obj
  98.             self.close_device = False
  99.         self.dir_stack = utils.Stack()
  100.         self.current_dir = []
  101.         self.device_uri = self.device.device_uri
  102.         self.pcard_mounted = False
  103.         self.saved_pwd = []
  104.         self.sector_buffer = { }
  105.         self.sector_buffer_counts = { }
  106.         self.cache_flag = True
  107.         self.write_protect = False
  108.         self.callback = None
  109.         self.channel_opened = False
  110.  
  111.     
  112.     def START_OPERATION(self, name = ''):
  113.         pass
  114.  
  115.     
  116.     def END_OPERATION(self, name = '', flag = True):
  117.         if self.channel_opened and flag:
  118.             self.close_channel()
  119.         
  120.  
  121.     
  122.     def set_callback(self, callback):
  123.         self.callback = callback
  124.  
  125.     
  126.     def _read(self, sector, nsector):
  127.         log.debug('read pcard sector: sector=%d count=%d' % (sector, nsector))
  128.         if self.cache_flag:
  129.             for s in range(sector, sector + nsector):
  130.                 if s not in self.sector_buffer:
  131.                     break
  132.                     continue
  133.             else:
  134.                 buffer = ''
  135.                 for s in range(sector, sector + nsector):
  136.                     buffer = ''.join([
  137.                         buffer,
  138.                         self.sector_buffer[s]])
  139.                     log.debug('Cached sector read sector=%d' % s)
  140.                     count = self.sector_buffer_counts[s]
  141.                     self.sector_buffer_counts[s] = count + 1
  142.                     if self.callback is not None:
  143.                         self.callback()
  144.                         continue
  145.                 
  146.                 return buffer
  147.         if self.callback is not None:
  148.             self.callback()
  149.         
  150.         if not self.channel_opened:
  151.             self.open_channel()
  152.         
  153.         log.debug('Normal sector read sector=%d count=%d' % (sector, nsector))
  154.         sectors_to_read = range(sector, sector + nsector)
  155.         request = struct.pack('!HH' + 'I' * nsector, READ_CMD, nsector, *sectors_to_read)
  156.         if self.callback is not None:
  157.             self.callback()
  158.         
  159.         bytes_written = self.device.writePCard(request)
  160.         log.debug('%d bytes written' % bytes_written)
  161.         data = self.device.readPCard(2)
  162.         code = struct.unpack('!H', data)[0]
  163.         log.debug('Return code: %x' % code)
  164.         if code == 272:
  165.             data = self.device.readPCard(6)
  166.             (nsector_read, ver) = struct.unpack('!IH', data)
  167.             log.debug('code=0x%x, nsector=%d, ver=%d' % (code, nsector_read, ver))
  168.             buffer = ''
  169.             data_read = 0
  170.             total_to_read = nsector * SECTOR_SIZE
  171.             while data_read < total_to_read:
  172.                 data = self.device.readPCard(total_to_read)
  173.                 data_read += len(data)
  174.                 buffer = ''.join([
  175.                     buffer,
  176.                     data])
  177.                 if self.callback is not None:
  178.                     self.callback()
  179.                     continue
  180.             if self.cache_flag:
  181.                 i = 0
  182.                 for s in range(sector, sector + nsector_read):
  183.                     self.sector_buffer[s] = buffer[i:i + SECTOR_SIZE]
  184.                     count = self.sector_buffer_counts.get(s, 0)
  185.                     self.sector_buffer_counts[s] = count + 1
  186.                     i += SECTOR_SIZE
  187.                     if self.callback is not None:
  188.                         self.callback()
  189.                         continue
  190.                 
  191.                 self._check_cache(nsector)
  192.             
  193.             return buffer
  194.         log.error('Error code: %d' % code)
  195.         return ''
  196.  
  197.     
  198.     def _write(self, sector, nsector, buffer):
  199.         log.debug('write pcard sector: sector=%d count=%d len=%d' % (sector, nsector, len(buffer)))
  200.         if not self.channel_opened:
  201.             self.open_channel()
  202.         
  203.         sectors_to_write = range(sector, sector + nsector)
  204.         request = struct.pack('!HHH' + 'I' * nsector, WRITE_CMD, nsector, 0, *sectors_to_write)
  205.         request = ''.join([
  206.             request,
  207.             buffer])
  208.         if self.callback is not None:
  209.             self.callback()
  210.         
  211.         self.device.writePCard(request)
  212.         data = self.device.readPCard(2)
  213.         if self.callback is not None:
  214.             self.callback()
  215.         
  216.         code = struct.unpack('!H', data)[0]
  217.         if code != NAK:
  218.             if self.cache_flag:
  219.                 i = 0
  220.                 for s in range(sector, sector + nsector):
  221.                     log.debug('Caching sector %d' % sector)
  222.                     self.sector_buffer[s] = buffer[i:i + SECTOR_SIZE]
  223.                     self.sector_buffer_counts[s] = 1
  224.                     i += SECTOR_SIZE
  225.                 
  226.                 if self.callback is not None:
  227.                     self.callback()
  228.                 
  229.                 self._check_cache(nsector)
  230.             
  231.             return 0
  232.         log.error('Photo card write failed (Card may be write protected)')
  233.         self.close_channel()
  234.         return 1
  235.  
  236.     
  237.     def _check_cache(self, nsector):
  238.         if len(self.sector_buffer) > MAX_CACHE:
  239.             t = self.sector_buffer.keys()[:]
  240.             n = 0
  241.             for s in t:
  242.                 if self.sector_buffer_counts[s] == 1:
  243.                     del self.sector_buffer[s]
  244.                     del self.sector_buffer_counts[s]
  245.                     n += 1
  246.                     if n >= nsector:
  247.                         break
  248.                     
  249.                     if self.callback is not None:
  250.                         self.callback()
  251.                     
  252.                 self.callback is not None
  253.             
  254.         
  255.  
  256.     
  257.     def cache_info(self):
  258.         return self.sector_buffer_counts
  259.  
  260.     
  261.     def cache_check(self, sector):
  262.         return self.sector_buffer_counts.get(sector, 0)
  263.  
  264.     
  265.     def cache_control(self, control):
  266.         self.cache_flag = control
  267.         if not self.cache_flag:
  268.             self.cache_reset()
  269.         
  270.  
  271.     
  272.     def cache_state(self):
  273.         return self.cache_flag
  274.  
  275.     
  276.     def cache_reset(self):
  277.         self.sector_buffer.clear()
  278.         self.sector_buffer_counts.clear()
  279.  
  280.     
  281.     def df(self):
  282.         df = 0
  283.         self.START_OPERATION('df')
  284.         
  285.         try:
  286.             df = pcardext.df()
  287.         finally:
  288.             self.END_OPERATION('df')
  289.             return df
  290.  
  291.  
  292.     
  293.     def ls(self, force_read = True, glob_list = '*', openclose = True):
  294.         if not glob_list:
  295.             glob_list = '*'
  296.         
  297.         if force_read:
  298.             self.START_OPERATION('ls')
  299.             
  300.             try:
  301.                 self.current_dir = pcardext.ls()
  302.             finally:
  303.                 self.END_OPERATION('ls', openclose)
  304.  
  305.         
  306.         self.current_dir = [ (n.lower(), a, s) for n, a, s in self.current_dir ]
  307.         if glob_list == '*':
  308.             return self.current_dir
  309.         return [ fnmatch.filter(self.current_dir, x) for x in glob_list.strip().lower().split() ][0]
  310.  
  311.     
  312.     def size(self, name):
  313.         for f in self.current_dir:
  314.             if f == name:
  315.                 return self.current_dir[f][2]
  316.         
  317.         return 0
  318.  
  319.     
  320.     def current_files(self):
  321.         return _[1]
  322.  
  323.     
  324.     def current_directories(self):
  325.         return _[1]
  326.  
  327.     
  328.     def match_files(self, glob_list):
  329.         if len(glob_list) > 0:
  330.             current_files = [ x[0] for x in self.current_files() ]
  331.             return [ fnmatch.filter(current_files, x) for x in glob_list.strip().lower().split() ][0]
  332.         return []
  333.  
  334.     
  335.     def match_dirs(self, glob_list):
  336.         if len(glob_list) > 0:
  337.             current_dirs = [ x[0] for x in self.current_directories() ]
  338.             return [ fnmatch.filter(current_dirs, x) for x in glob_list.strip().lower().split() ][0]
  339.         return []
  340.  
  341.     
  342.     def classify_file(self, filename):
  343.         t = mimetypes.guess_type(filename)[0]
  344.         if t is None:
  345.             return 'unknown/unknown'
  346.         return t
  347.  
  348.     
  349.     def cp(self, name, local_file, openclose = True):
  350.         self.START_OPERATION('cp')
  351.         total = 0
  352.         
  353.         try:
  354.             f = file(local_file, 'w')
  355.             total = pcardext.cp(name, f.fileno())
  356.             f.close()
  357.         finally:
  358.             self.END_OPERATION('cp', openclose)
  359.             return total
  360.  
  361.  
  362.     
  363.     def cp_multiple(self, filelist, remove_after_copy, cp_status_callback = None, rm_status_callback = None):
  364.         (delta, total) = (0, 0)
  365.         self.START_OPERATION('cp_multiple')
  366.         t1 = time.time()
  367.         
  368.         try:
  369.             for f in filelist:
  370.                 size = self.cp(f, f, False)
  371.                 if cp_status_callback:
  372.                     cp_status_callback(os.path.join(self.pwd(), f), os.path.join(os.getcwd(), f), size)
  373.                 
  374.                 total += size
  375.                 if remove_after_copy:
  376.                     pcardext.rm(f)
  377.                 
  378.             
  379.             t2 = time.time()
  380.             delta = t2 - t1
  381.         finally:
  382.             if remove_after_copy:
  383.                 self.ls(True, '*', False)
  384.             
  385.             self.END_OPERATION('cp_multiple')
  386.             return (total, delta)
  387.  
  388.  
  389.     
  390.     def cp_list(self, filelist, remove_after_copy, cp_status_callback = None, rm_status_callback = None):
  391.         self.save_wd()
  392.         (delta, total) = (0, 0)
  393.         self.START_OPERATION('cp_list')
  394.         t1 = time.time()
  395.         
  396.         try:
  397.             for f in filelist:
  398.                 path_list = f.split('/')[:-1]
  399.                 filename = f.split('/')[-1]
  400.                 for p in path_list:
  401.                     self.cd(p, False)
  402.                 
  403.                 size = self.cp(filename, filename, False)
  404.                 if cp_status_callback is not None:
  405.                     cp_status_callback(f, os.path.join(os.getcwd(), filename), size)
  406.                 
  407.                 total += size
  408.                 if remove_after_copy:
  409.                     pcardext.rm(filename)
  410.                     if rm_status_callback is not None:
  411.                         rm_status_callback(f)
  412.                     
  413.                 
  414.                 self.cd('/', False)
  415.             
  416.             t2 = time.time()
  417.             delta = t2 - t1
  418.         finally:
  419.             self.restore_wd()
  420.             self.END_OPERATION('cp_list')
  421.             return (total, delta)
  422.  
  423.  
  424.     
  425.     def cp_fd(self, name, fd):
  426.         total = 0
  427.         self.START_OPERATION('cp_fd')
  428.         
  429.         try:
  430.             total = pcardext.cp(name, fd)
  431.         finally:
  432.             self.END_OPERATION('cp_fd')
  433.             return total
  434.  
  435.  
  436.     
  437.     def unload(self, unload_list, cp_status_callback = None, rm_status_callback = None, dont_remove = False):
  438.         was_cancelled = False
  439.         self.save_wd()
  440.         self.START_OPERATION('unload')
  441.         total = 0
  442.         t1 = time.time()
  443.         for f in unload_list:
  444.             if not was_cancelled:
  445.                 (name, size, typ, subtyp) = f
  446.                 p = name.split('/')
  447.                 dirs = p[:-1]
  448.                 filename = p[-1]
  449.                 self.cd('/', False)
  450.                 if cp_status_callback is not None:
  451.                     if cp_status_callback(os.path.join(self.pwd(), filename), os.path.join(os.getcwd(), filename), 0):
  452.                         was_cancelled = True
  453.                         break
  454.                     
  455.                 
  456.                 if len(dirs) > 0:
  457.                     for d in dirs:
  458.                         self.cd(d, False)
  459.                     
  460.                 
  461.                 if os.path.exists(os.path.join(os.getcwd(), filename)):
  462.                     i = 2
  463.                     while True:
  464.                         if not os.path.exists(os.path.join(os.getcwd(), filename + ' (%d)' % i)):
  465.                             break
  466.                         
  467.                         i += 1
  468.                     total += self.cp(filename, filename + ' (%d)' % i, False)
  469.                 else:
  470.                     total += self.cp(filename, filename, False)
  471.                 if cp_status_callback is not None:
  472.                     if cp_status_callback(os.path.join(self.pwd(), filename), os.path.join(os.getcwd(), filename), size):
  473.                         was_cancelled = True
  474.                         break
  475.                     
  476.                 
  477.                 if not dont_remove:
  478.                     if rm_status_callback is not None:
  479.                         rm_status_callback(os.path.join(self.pwd(), filename))
  480.                     
  481.                     self.rm(filename, False, False)
  482.                 
  483.             dont_remove
  484.         
  485.         t2 = time.time()
  486.         self.restore_wd(False)
  487.         self.ls(True, '*', False)
  488.         self.END_OPERATION('unload')
  489.         return (total, t2 - t1, was_cancelled)
  490.  
  491.     
  492.     def get_unload_list(self):
  493.         tree = self.tree()
  494.         return self._PhotoCard__build_unload_list(tree)
  495.  
  496.     
  497.     def __build_unload_list(self, tree, path = None, out = None):
  498.         if path is None:
  499.             out = []
  500.             path = utils.Stack()
  501.         
  502.         for d in tree:
  503.             if type(tree[d]) == type({ }):
  504.                 path.push(d)
  505.                 self._PhotoCard__build_unload_list(tree[d], path, out)
  506.                 path.pop()
  507.                 continue
  508.             (typ, subtyp) = self.classify_file(d).split('/')
  509.             if typ in ('image', 'audio', 'video'):
  510.                 p = path.as_list()
  511.                 name = '/'.join([
  512.                     '/'.join(p),
  513.                     d])
  514.                 out.append((name, tree[d], typ, subtyp))
  515.                 continue
  516.         
  517.         return out
  518.  
  519.     
  520.     def info(self):
  521.         return pcardext.info()
  522.  
  523.     
  524.     def cd(self, dirs, openclose = True):
  525.         self.START_OPERATION('cd')
  526.         
  527.         try:
  528.             stat = pcardext.cd(dirs)
  529.             if stat:
  530.                 if dirs == '/':
  531.                     self.dir_stack.clear()
  532.                 else:
  533.                     dirs = dirs.split('/')
  534.                     for d in dirs:
  535.                         self.dir_stack.push(d)
  536.                     
  537.                 self.ls(True, '*', False)
  538.         finally:
  539.             self.END_OPERATION('cd', openclose)
  540.  
  541.  
  542.     
  543.     def cdup(self, openclose = True):
  544.         if len(self.dir_stack.as_list()) == 0:
  545.             return self.cd('/', openclose)
  546.         self.dir_stack.pop()
  547.         self.START_OPERATION('cdup')
  548.         
  549.         try:
  550.             pcardext.cd('/')
  551.             for d in self.dir_stack.as_list():
  552.                 pcardext.cd(d)
  553.             
  554.             self.ls(True, '*', False)
  555.         finally:
  556.             self.END_OPERATION('cdup', openclose)
  557.  
  558.  
  559.     
  560.     def rm(self, name, refresh_dir = True, openclose = True):
  561.         self.START_OPERATION()
  562.         
  563.         try:
  564.             r = pcardext.rm(name)
  565.             if refresh_dir:
  566.                 self.ls(True, '*', False)
  567.         finally:
  568.             self.END_OPERATION(openclose)
  569.             return r
  570.  
  571.  
  572.     
  573.     def mount(self):
  574.         log.debug('Mounting photocard...')
  575.         self.START_OPERATION('mount')
  576.         
  577.         try:
  578.             stat = pcardext.mount(self._read, self._write)
  579.             disk_info = pcardext.info()
  580.             self.write_protect = disk_info[8]
  581.             log.debug('stat=%d' % stat)
  582.             if stat == 0:
  583.                 if self.write_protect:
  584.                     self.open_channel()
  585.                 
  586.                 self.pcard_mounted = True
  587.                 pcardext.cd('/')
  588.                 self.ls(True, '*', False)
  589.             else:
  590.                 self.pcard_mounted = False
  591.                 raise Error(ERROR_DEVICE_DOES_NOT_SUPPORT_OPERATION)
  592.             return None
  593.  
  594.  
  595.     
  596.     def pwd(self):
  597.         return '/' + '/'.join(self.dir_stack.as_list())
  598.  
  599.     
  600.     def save_wd(self):
  601.         self.saved_pwd = self.dir_stack.as_list()[:]
  602.  
  603.     
  604.     def restore_wd(self, openclose = True):
  605.         self.cd('/', openclose)
  606.         for d in self.saved_pwd:
  607.             self.cd(d, openclose)
  608.         
  609.  
  610.     
  611.     def tree(self):
  612.         self.START_OPERATION('tree')
  613.         dir_tree = { }
  614.         
  615.         try:
  616.             self.save_wd()
  617.             dir_tree = self._PhotoCard__tree()
  618.             self.restore_wd(False)
  619.         finally:
  620.             self.END_OPERATION('tree')
  621.             return dir_tree
  622.  
  623.  
  624.     
  625.     def __tree(self, _PhotoCard__d = None):
  626.         if _PhotoCard__d is None:
  627.             _PhotoCard__d = { }
  628.             pcardext.cd('/')
  629.         
  630.         for f in pcardext.ls():
  631.             fname = f[0].lower()
  632.             if self.callback is not None:
  633.                 self.callback()
  634.             
  635.             if fname not in ('.', '..'):
  636.                 if f[1] == 'd':
  637.                     self.cd(fname, False)
  638.                     _PhotoCard__d[fname] = { }
  639.                     _PhotoCard__d[fname] = self._PhotoCard__tree(_PhotoCard__d[fname])
  640.                     self.cdup(False)
  641.                 else:
  642.                     _PhotoCard__d[fname] = f[2]
  643.             f[1] == 'd'
  644.         
  645.         return _PhotoCard__d
  646.  
  647.     
  648.     def get_exif(self, name):
  649.         exif_info = { }
  650.         self.START_OPERATION('get_exif')
  651.         pcf = None
  652.         
  653.         try:
  654.             pcf = PhotoCardFile(self, name)
  655.             exif_info = exif.process_file(pcf)
  656.         finally:
  657.             if pcf is not None:
  658.                 pcf.close()
  659.             
  660.             self.END_OPERATION('get_exif')
  661.             return exif_info
  662.  
  663.  
  664.     
  665.     def get_exif_path(self, name):
  666.         exif_info = { }
  667.         self.START_OPERATION('get_exif_path')
  668.         self.save_wd()
  669.         
  670.         try:
  671.             path_list = name.split('/')[:-1]
  672.             filename = name.split('/')[-1]
  673.             for p in path_list:
  674.                 self.cd(p, False)
  675.             
  676.             pcf = PhotoCardFile(self, filename)
  677.             exif_info = exif.process_file(pcf)
  678.         finally:
  679.             self.restore_wd(False)
  680.             pcf.close()
  681.             self.END_OPERATION('get_exif_path')
  682.             return exif_info
  683.  
  684.  
  685.     
  686.     def sector(self, sector):
  687.         self.START_OPERATION('sector')
  688.         
  689.         try:
  690.             data = self._read(sector, 1)
  691.         finally:
  692.             self.END_OPERATION('sector')
  693.             return data
  694.  
  695.  
  696.     
  697.     def umount(self):
  698.         pcardext.umount()
  699.         self.pcard_mounted = False
  700.  
  701.     
  702.     def open_channel(self):
  703.         self.channel_opened = True
  704.         self.device.openPCard()
  705.  
  706.     
  707.     def close_channel(self):
  708.         self.channel_opened = False
  709.         self.device.closePCard()
  710.  
  711.  
  712.